home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / TreeC2.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  62KB  |  1,765 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Sets
  20. #include "Sets.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Positions
  28. #include "Positions.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Tree
  32. #include "Tree.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeC2
  36. #include "TreeC2.h"
  37. #endif
  38.  
  39. Tree_tTree TreeC2_Iterator;
  40. IO_tFile TreeC2_yyf;
  41. PROC TreeC2_Exit;
  42.  
  43. static Idents_tIdent iClassName;
  44. static Tree_tTree RevChild;
  45. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  46. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  47. struct S_3 {
  48.     union {
  49.         char dummy;
  50.     } U_1;
  51. };
  52. static void WriteNodeName ARGS((Tree_tTree t));
  53. struct S_4 {
  54.     union {
  55.         char dummy;
  56.     } U_1;
  57. };
  58. static void WriteNode ARGS((Tree_tTree t));
  59. struct S_5 {
  60.     union {
  61.         char dummy;
  62.     } U_1;
  63. };
  64. static void Mark ARGS((Tree_tTree t));
  65. struct S_6 {
  66.     union {
  67.         char dummy;
  68.     } U_1;
  69. };
  70. static void WriteClassName ARGS((Tree_tTree t));
  71. struct S_7 {
  72.     union {
  73.         char dummy;
  74.     } U_1;
  75. };
  76. static void WriteAttributes ARGS((Tree_tTree t));
  77. struct S_8 {
  78.     union {
  79.         char dummy;
  80.     } U_1;
  81. };
  82. static void ReadAttributes ARGS((Tree_tTree t));
  83. struct S_9 {
  84.     union {
  85.         char dummy;
  86.     } U_1;
  87. };
  88. static void PutAttributes ARGS((Tree_tTree t));
  89. struct S_10 {
  90.     union {
  91.         char dummy;
  92.     } U_1;
  93. };
  94. static void GetAttributes ARGS((Tree_tTree t));
  95. struct S_11 {
  96.     union {
  97.         char dummy;
  98.     } U_1;
  99. };
  100. struct S_12 {
  101.     union {
  102.         char dummy;
  103.     } U_1;
  104. };
  105. static void yyExit ARGS(());
  106.  
  107.  
  108. void TreeC2_WriteLine
  109. # ifdef __STDC__
  110. (Positions_tPosition Line)
  111. # else
  112. (Line)
  113. Positions_tPosition Line;
  114. # endif
  115. {
  116.   if (Line.Line != 0) {
  117.     if (Sets_IsElement(ORD('6'), &Tree_Options)) {
  118.       IO_WriteS(Tree_f, (STRING)"# line ", 7L);
  119.       Tree_WN((LONGINT)Line.Line);
  120.       IO_WriteS(Tree_f, (STRING)" \"", 2L);
  121.       Tree_WI(Line.File);
  122.       IO_WriteS(Tree_f, (STRING)"\"", 1L);
  123.       IO_WriteNl(Tree_f);
  124.     } else {
  125.       IO_WriteS(Tree_f, (STRING)"/* line ", 8L);
  126.       Tree_WN((LONGINT)Line.Line);
  127.       IO_WriteS(Tree_f, (STRING)" \"", 2L);
  128.       Tree_WI(Line.File);
  129.       IO_WriteS(Tree_f, (STRING)"\" */", 4L);
  130.       IO_WriteNl(Tree_f);
  131.     }
  132.   }
  133. }
  134.  
  135. static void yyAbort
  136. # ifdef __STDC__
  137. (CHAR yyFunction[], LONGCARD O_1)
  138. # else
  139. (yyFunction, O_1)
  140. CHAR yyFunction[];
  141. LONGCARD O_1;
  142. # endif
  143. {
  144.   OPEN_ARRAY_LOCALS
  145.  
  146.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  147.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  148.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module TreeC2, routine ", 30L);
  149.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  150.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  151.   IO_WriteNl((System_tFile)IO_StdError);
  152.   (*TreeC2_Exit)();
  153.   FREE_OPEN_ARRAYS
  154. }
  155.  
  156. static BOOLEAN yyIsEqual
  157. # ifdef __STDC__
  158. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  159. # else
  160. (yya, O_3, yyb, O_2)
  161. BYTE yya[];
  162. LONGCARD O_3;
  163. BYTE yyb[];
  164. LONGCARD O_2;
  165. # endif
  166. {
  167.   INTEGER yyi;
  168.   OPEN_ARRAY_LOCALS
  169.  
  170.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  171.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  172.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  173.   {
  174.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  175.  
  176.     if (B_1 <= B_2)
  177.       for (yyi = B_1;; yyi += 1) {
  178.         if (yya[yyi] != yyb[yyi]) {
  179.           FREE_OPEN_ARRAYS
  180.           return FALSE;
  181.         }
  182.         if (yyi >= B_2) break;
  183.       }
  184.   }
  185.   FREE_OPEN_ARRAYS
  186.   return TRUE;
  187. }
  188.  
  189. void TreeC2_TreeIO
  190. # ifdef __STDC__
  191. (Tree_tTree t)
  192. # else
  193. (t)
  194. Tree_tTree t;
  195. # endif
  196. {
  197.   struct S_3 yyTempo;
  198.  
  199.   if (t == Tree_NoTree) {
  200.     return;
  201.   }
  202.   if (t->U_1.V_1.Kind == Tree_Ag) {
  203.     {
  204.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  205.  
  206.       IO_WriteS(Tree_f, (STRING)"typedef ", 8L);
  207.       Tree_WI(Tree_itTree);
  208.       IO_WriteS(Tree_f, (STRING)" * yyPtrtTree;", 14L);
  209.       IO_WriteNl(Tree_f);
  210.       IO_WriteNl(Tree_f);
  211.       IO_WriteS(Tree_f, (STRING)"static FILE * yyf;", 18L);
  212.       IO_WriteNl(Tree_f);
  213.       IO_WriteNl(Tree_f);
  214.       if (Sets_IsElement(ORD(','), &Tree_Options)) {
  215.         IO_WriteS(Tree_f, (STRING)"static void yyMark", 18L);
  216.         IO_WriteNl(Tree_f);
  217.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  218.         IO_WriteNl(Tree_f);
  219.         IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  220.         Tree_WI(Tree_itTree);
  221.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  222.         IO_WriteNl(Tree_f);
  223.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  224.         IO_WriteNl(Tree_f);
  225.         IO_WriteS(Tree_f, (STRING)" (yyt) register ", 16L);
  226.         Tree_WI(Tree_itTree);
  227.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  228.         IO_WriteNl(Tree_f);
  229.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  230.         IO_WriteNl(Tree_f);
  231.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  232.         IO_WriteNl(Tree_f);
  233.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  234.         IO_WriteNl(Tree_f);
  235.         IO_WriteS(Tree_f, (STRING)"  if (yyt == ", 13L);
  236.         Tree_WI(Tree_iNoTree);
  237.         IO_WriteS(Tree_f, (STRING)" || ++ yyt->yyHead.yyMark > 1) return;", 38L);
  238.         IO_WriteNl(Tree_f);
  239.         IO_WriteNl(Tree_f);
  240.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  241.         IO_WriteNl(Tree_f);
  242.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)Mark);
  243.         IO_WriteS(Tree_f, (STRING)"  default: return;", 18L);
  244.         IO_WriteNl(Tree_f);
  245.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  246.         IO_WriteNl(Tree_f);
  247.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  248.         IO_WriteNl(Tree_f);
  249.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  250.         IO_WriteNl(Tree_f);
  251.         IO_WriteNl(Tree_f);
  252.       }
  253.       if (Sets_IsElement(ORD(';'), &Tree_Options)) {
  254.         IO_WriteS(Tree_f, (STRING)"# define yyInitTreeStoreSize 32", 31L);
  255.         IO_WriteNl(Tree_f);
  256.         IO_WriteS(Tree_f, (STRING)"# define yyMapToTree(yyLabel) yyTreeStorePtr [yyLabel]", 54L);
  257.         IO_WriteNl(Tree_f);
  258.         IO_WriteNl(Tree_f);
  259.         IO_WriteS(Tree_f, (STRING)"static unsigned long yyTreeStoreSize = yyInitTreeStoreSize;", 59L);
  260.         IO_WriteNl(Tree_f);
  261.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  262.         Tree_WI(Tree_itTree);
  263.         IO_WriteS(Tree_f, (STRING)" yyTreeStore [yyInitTreeStoreSize];", 35L);
  264.         IO_WriteNl(Tree_f);
  265.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  266.         Tree_WI(Tree_itTree);
  267.         IO_WriteS(Tree_f, (STRING)" * yyTreeStorePtr = yyTreeStore;", 32L);
  268.         IO_WriteNl(Tree_f);
  269.         IO_WriteS(Tree_f, (STRING)"static int yyLabelCount;", 24L);
  270.         IO_WriteNl(Tree_f);
  271.         IO_WriteS(Tree_f, (STRING)"static short yyRecursionLevel = 0;", 34L);
  272.         IO_WriteNl(Tree_f);
  273.         IO_WriteNl(Tree_f);
  274.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  275.         Tree_WI(Tree_iMain);
  276.         IO_WriteS(Tree_f, (STRING)"_tLabel yyMapToLabel", 20L);
  277.         IO_WriteNl(Tree_f);
  278.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  279.         IO_WriteNl(Tree_f);
  280.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  281.         Tree_WI(Tree_itTree);
  282.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  283.         IO_WriteNl(Tree_f);
  284.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  285.         IO_WriteNl(Tree_f);
  286.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  287.         Tree_WI(Tree_itTree);
  288.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  289.         IO_WriteNl(Tree_f);
  290.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  291.         IO_WriteNl(Tree_f);
  292.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  293.         IO_WriteNl(Tree_f);
  294.         IO_WriteS(Tree_f, (STRING)" register int yyi;", 18L);
  295.         IO_WriteNl(Tree_f);
  296.         IO_WriteS(Tree_f, (STRING)" for (yyi = 1; yyi <= yyLabelCount; yyi ++) if (yyTreeStorePtr [yyi] == yyt) return yyi;", 88L);
  297.         IO_WriteNl(Tree_f);
  298.         IO_WriteS(Tree_f, (STRING)" if (++ yyLabelCount == yyTreeStoreSize)", 40L);
  299.         IO_WriteNl(Tree_f);
  300.         IO_WriteS(Tree_f, (STRING)"  ExtendArray ((char * *) & yyTreeStorePtr, & yyTreeStoreSize, sizeof (", 71L);
  301.         Tree_WI(Tree_itTree);
  302.         IO_WriteS(Tree_f, (STRING)"));", 3L);
  303.         IO_WriteNl(Tree_f);
  304.         IO_WriteS(Tree_f, (STRING)" yyTreeStorePtr [yyLabelCount] = yyt;", 37L);
  305.         IO_WriteNl(Tree_f);
  306.         IO_WriteS(Tree_f, (STRING)" return yyLabelCount;", 21L);
  307.         IO_WriteNl(Tree_f);
  308.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  309.         IO_WriteNl(Tree_f);
  310.         IO_WriteNl(Tree_f);
  311.       }
  312.       if (Sets_IsElement(ORD('w'), &Tree_Options) || Sets_IsElement(ORD('o'), &Tree_Options)) {
  313.         IO_WriteS(Tree_f, (STRING)"static void yyWrite", 19L);
  314.         Tree_WI(Tree_iModule);
  315.         IO_WriteS(Tree_f, (STRING)" ();", 4L);
  316.         IO_WriteNl(Tree_f);
  317.         IO_WriteNl(Tree_f);
  318.         IO_WriteS(Tree_f, (STRING)"static void yyWriteNl () { (void) putc ('\\n', yyf); }", 53L);
  319.         IO_WriteNl(Tree_f);
  320.         IO_WriteNl(Tree_f);
  321.         IO_WriteS(Tree_f, (STRING)"static void yyWriteSelector", 27L);
  322.         IO_WriteNl(Tree_f);
  323.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  324.         IO_WriteNl(Tree_f);
  325.         IO_WriteS(Tree_f, (STRING)" (char * yys)", 13L);
  326.         IO_WriteNl(Tree_f);
  327.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  328.         IO_WriteNl(Tree_f);
  329.         IO_WriteS(Tree_f, (STRING)" (yys) char * yys;", 18L);
  330.         IO_WriteNl(Tree_f);
  331.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  332.         IO_WriteNl(Tree_f);
  333.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  334.         IO_WriteNl(Tree_f);
  335.         IO_WriteS(Tree_f, (STRING)" register int yyi = 16 - strlen (yys);", 38L);
  336.         IO_WriteNl(Tree_f);
  337.         IO_WriteS(Tree_f, (STRING)" (void) fputs (yys, yyf);", 25L);
  338.         IO_WriteNl(Tree_f);
  339.         IO_WriteS(Tree_f, (STRING)" while (yyi -- > 0) (void) putc (' ', yyf);", 43L);
  340.         IO_WriteNl(Tree_f);
  341.         IO_WriteS(Tree_f, (STRING)" (void) fputs (\" = \", yyf);", 27L);
  342.         IO_WriteNl(Tree_f);
  343.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  344.         IO_WriteNl(Tree_f);
  345.         IO_WriteNl(Tree_f);
  346.         IO_WriteS(Tree_f, (STRING)"static void yyWriteHex", 22L);
  347.         IO_WriteNl(Tree_f);
  348.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  349.         IO_WriteNl(Tree_f);
  350.         IO_WriteS(Tree_f, (STRING)" (unsigned char * yyx, int yysize)", 34L);
  351.         IO_WriteNl(Tree_f);
  352.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  353.         IO_WriteNl(Tree_f);
  354.         IO_WriteS(Tree_f, (STRING)" (yyx, yysize) unsigned char * yyx; int yysize;", 47L);
  355.         IO_WriteNl(Tree_f);
  356.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  357.         IO_WriteNl(Tree_f);
  358.         IO_WriteS(Tree_f, (STRING)"{ register int yyi; for (yyi = 0; yyi < yysize; yyi ++) (void) fprintf (yyf, \"%02x \", yyx [yyi]); }", 99L);
  359.         IO_WriteNl(Tree_f);
  360.         IO_WriteNl(Tree_f);
  361.       }
  362.       if (Sets_IsElement(ORD('o'), &Tree_Options)) {
  363.         IO_WriteS(Tree_f, (STRING)"static void yyWriteAdr", 22L);
  364.         IO_WriteNl(Tree_f);
  365.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  366.         IO_WriteNl(Tree_f);
  367.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  368.         Tree_WI(Tree_itTree);
  369.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  370.         IO_WriteNl(Tree_f);
  371.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  372.         IO_WriteNl(Tree_f);
  373.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  374.         Tree_WI(Tree_itTree);
  375.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  376.         IO_WriteNl(Tree_f);
  377.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  378.         IO_WriteNl(Tree_f);
  379.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  380.         IO_WriteNl(Tree_f);
  381.         IO_WriteS(Tree_f, (STRING)" if (yyt == ", 12L);
  382.         Tree_WI(Tree_iNoTree);
  383.         IO_WriteS(Tree_f, (STRING)") (void) fputs (\"", 17L);
  384.         Tree_WI(Tree_iNoTree);
  385.         IO_WriteS(Tree_f, (STRING)"\", yyf);", 8L);
  386.         IO_WriteNl(Tree_f);
  387.         IO_WriteS(Tree_f, (STRING)" else yyWriteHex ((unsigned char *) & yyt, sizeof (yyt));", 57L);
  388.         IO_WriteNl(Tree_f);
  389.         IO_WriteS(Tree_f, (STRING)" yyWriteNl ();", 14L);
  390.         IO_WriteNl(Tree_f);
  391.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  392.         IO_WriteNl(Tree_f);
  393.         IO_WriteNl(Tree_f);
  394.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteNode);
  395.         IO_WriteS(Tree_f, (STRING)"void Write", 10L);
  396.         Tree_WI(Tree_iModule);
  397.         IO_WriteS(Tree_f, (STRING)"Node", 4L);
  398.         IO_WriteNl(Tree_f);
  399.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  400.         IO_WriteNl(Tree_f);
  401.         IO_WriteS(Tree_f, (STRING)" (FILE * yyyf, ", 15L);
  402.         Tree_WI(Tree_itTree);
  403.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  404.         IO_WriteNl(Tree_f);
  405.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  406.         IO_WriteNl(Tree_f);
  407.         IO_WriteS(Tree_f, (STRING)" (yyyf, yyt) FILE * yyyf; ", 26L);
  408.         Tree_WI(Tree_itTree);
  409.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  410.         IO_WriteNl(Tree_f);
  411.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  412.         IO_WriteNl(Tree_f);
  413.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  414.         IO_WriteNl(Tree_f);
  415.         IO_WriteS(Tree_f, (STRING)" yyf = yyyf;", 12L);
  416.         IO_WriteNl(Tree_f);
  417.         IO_WriteS(Tree_f, (STRING)" if (yyt == ", 12L);
  418.         Tree_WI(Tree_iNoTree);
  419.         IO_WriteS(Tree_f, (STRING)") { (void) fputs (\"", 19L);
  420.         Tree_WI(Tree_iNoTree);
  421.         IO_WriteS(Tree_f, (STRING)"\\n\", yyf); return; }", 20L);
  422.         IO_WriteNl(Tree_f);
  423.         IO_WriteNl(Tree_f);
  424.         IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  425.         IO_WriteNl(Tree_f);
  426.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteNodeName);
  427.         IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  428.         IO_WriteNl(Tree_f);
  429.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  430.         IO_WriteNl(Tree_f);
  431.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  432.         IO_WriteNl(Tree_f);
  433.         IO_WriteNl(Tree_f);
  434.       }
  435.       if (Sets_IsElement(ORD('w'), &Tree_Options)) {
  436.         IO_WriteS(Tree_f, (STRING)"static short yyIndentLevel;", 27L);
  437.         IO_WriteNl(Tree_f);
  438.         IO_WriteNl(Tree_f);
  439.         IO_WriteS(Tree_f, (STRING)"void Write", 10L);
  440.         Tree_WI(Tree_iModule);
  441.         IO_WriteNl(Tree_f);
  442.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  443.         IO_WriteNl(Tree_f);
  444.         IO_WriteS(Tree_f, (STRING)" (FILE * yyyf, ", 15L);
  445.         Tree_WI(Tree_itTree);
  446.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  447.         IO_WriteNl(Tree_f);
  448.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  449.         IO_WriteNl(Tree_f);
  450.         IO_WriteS(Tree_f, (STRING)" (yyyf, yyt) FILE * yyyf; ", 26L);
  451.         Tree_WI(Tree_itTree);
  452.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  453.         IO_WriteNl(Tree_f);
  454.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  455.         IO_WriteNl(Tree_f);
  456.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  457.         IO_WriteNl(Tree_f);
  458.         IO_WriteS(Tree_f, (STRING)" short yySaveLevel = yyIndentLevel;", 35L);
  459.         IO_WriteNl(Tree_f);
  460.         IO_WriteS(Tree_f, (STRING)" yyf = yyyf;", 12L);
  461.         IO_WriteNl(Tree_f);
  462.         IO_WriteS(Tree_f, (STRING)" if (yyRecursionLevel ++ == 0) yyLabelCount = 0;", 48L);
  463.         IO_WriteNl(Tree_f);
  464.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  465.         IO_WriteNl(Tree_f);
  466.         IO_WriteS(Tree_f, (STRING)" yyIndentLevel = 0;", 19L);
  467.         IO_WriteNl(Tree_f);
  468.         IO_WriteS(Tree_f, (STRING)" yyWrite", 8L);
  469.         Tree_WI(Tree_iModule);
  470.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  471.         IO_WriteNl(Tree_f);
  472.         IO_WriteS(Tree_f, (STRING)" yyIndentLevel = yySaveLevel;", 29L);
  473.         IO_WriteNl(Tree_f);
  474.         IO_WriteS(Tree_f, (STRING)" yyRecursionLevel --;", 21L);
  475.         IO_WriteNl(Tree_f);
  476.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  477.         IO_WriteNl(Tree_f);
  478.         IO_WriteNl(Tree_f);
  479.         IO_WriteS(Tree_f, (STRING)"static void yyIndentSelector", 28L);
  480.         IO_WriteNl(Tree_f);
  481.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  482.         IO_WriteNl(Tree_f);
  483.         IO_WriteS(Tree_f, (STRING)" (char * yys)", 13L);
  484.         IO_WriteNl(Tree_f);
  485.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  486.         IO_WriteNl(Tree_f);
  487.         IO_WriteS(Tree_f, (STRING)" (yys) char * yys;", 18L);
  488.         IO_WriteNl(Tree_f);
  489.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  490.         IO_WriteNl(Tree_f);
  491.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  492.         IO_WriteNl(Tree_f);
  493.         IO_WriteS(Tree_f, (STRING)" register int yyi;", 18L);
  494.         IO_WriteNl(Tree_f);
  495.         IO_WriteS(Tree_f, (STRING)" for (yyi = 1; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);", 68L);
  496.         IO_WriteNl(Tree_f);
  497.         IO_WriteS(Tree_f, (STRING)" yyWriteSelector (yys);", 23L);
  498.         IO_WriteNl(Tree_f);
  499.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  500.         IO_WriteNl(Tree_f);
  501.         IO_WriteNl(Tree_f);
  502.         IO_WriteS(Tree_f, (STRING)"static void yyIndentSelectorTree", 32L);
  503.         IO_WriteNl(Tree_f);
  504.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  505.         IO_WriteNl(Tree_f);
  506.         IO_WriteS(Tree_f, (STRING)" (char * yys, ", 14L);
  507.         Tree_WI(Tree_itTree);
  508.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  509.         IO_WriteNl(Tree_f);
  510.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  511.         IO_WriteNl(Tree_f);
  512.         IO_WriteS(Tree_f, (STRING)" (yys, yyt) char * yys; ", 24L);
  513.         Tree_WI(Tree_itTree);
  514.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  515.         IO_WriteNl(Tree_f);
  516.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  517.         IO_WriteNl(Tree_f);
  518.         IO_WriteS(Tree_f, (STRING)"{ yyIndentSelector (yys); write", 31L);
  519.         Tree_WI(Tree_itTree);
  520.         IO_WriteS(Tree_f, (STRING)" (yyt) }", 8L);
  521.         IO_WriteNl(Tree_f);
  522.         IO_WriteNl(Tree_f);
  523.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteAttributes);
  524.         IO_WriteS(Tree_f, (STRING)"static void yyWrite", 19L);
  525.         Tree_WI(Tree_iModule);
  526.         IO_WriteNl(Tree_f);
  527.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  528.         IO_WriteNl(Tree_f);
  529.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  530.         Tree_WI(Tree_itTree);
  531.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  532.         IO_WriteNl(Tree_f);
  533.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  534.         IO_WriteNl(Tree_f);
  535.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  536.         Tree_WI(Tree_itTree);
  537.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  538.         IO_WriteNl(Tree_f);
  539.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  540.         IO_WriteNl(Tree_f);
  541.         IO_WriteS(Tree_f, (STRING)"{ unsigned short yyLevel = yyIndentLevel;", 41L);
  542.         IO_WriteNl(Tree_f);
  543.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  544.         IO_WriteNl(Tree_f);
  545.         IO_WriteS(Tree_f, (STRING)"  if (yyt == ", 13L);
  546.         Tree_WI(Tree_iNoTree);
  547.         IO_WriteS(Tree_f, (STRING)") { (void) fputs (\" ", 20L);
  548.         Tree_WI(Tree_iNoTree);
  549.         IO_WriteS(Tree_f, (STRING)"\\n\", yyf); goto yyExit;", 23L);
  550.         IO_WriteNl(Tree_f);
  551.         IO_WriteS(Tree_f, (STRING)"  } else if (yyt->yyHead.yyMark == 0) { (void) fprintf (yyf, \"^%d\\n\", yyMapToLabel (yyt)); goto yyExit;", 103L);
  552.         IO_WriteNl(Tree_f);
  553.         IO_WriteS(Tree_f, (STRING)"  } else if (yyt->yyHead.yyMark > 1) {", 38L);
  554.         IO_WriteNl(Tree_f);
  555.         IO_WriteS(Tree_f, (STRING)"   register int yyi;", 20L);
  556.         IO_WriteNl(Tree_f);
  557.         IO_WriteS(Tree_f, (STRING)"   (void) fprintf (yyf, \"\\n%06d:\", yyMapToLabel (yyt));", 55L);
  558.         IO_WriteNl(Tree_f);
  559.         IO_WriteS(Tree_f, (STRING)"   for (yyi = 8; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);", 70L);
  560.         IO_WriteNl(Tree_f);
  561.         IO_WriteS(Tree_f, (STRING)"  } else (void) putc (' ', yyf);", 32L);
  562.         IO_WriteNl(Tree_f);
  563.         IO_WriteS(Tree_f, (STRING)"  yyt->yyHead.yyMark = 0;", 25L);
  564.         IO_WriteNl(Tree_f);
  565.         IO_WriteS(Tree_f, (STRING)"  yyIndentLevel += 2;", 21L);
  566.         IO_WriteNl(Tree_f);
  567.         IO_WriteNl(Tree_f);
  568.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  569.         IO_WriteNl(Tree_f);
  570.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)WriteClassName);
  571.         IO_WriteS(Tree_f, (STRING)"  default: goto yyExit;", 23L);
  572.         IO_WriteNl(Tree_f);
  573.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  574.         IO_WriteNl(Tree_f);
  575.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  576.         IO_WriteNl(Tree_f);
  577.         IO_WriteS(Tree_f, (STRING)"yyExit:", 7L);
  578.         IO_WriteNl(Tree_f);
  579.         IO_WriteS(Tree_f, (STRING)" yyIndentLevel = yyLevel;", 25L);
  580.         IO_WriteNl(Tree_f);
  581.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  582.         IO_WriteNl(Tree_f);
  583.         IO_WriteNl(Tree_f);
  584.       }
  585.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  586.         IO_WriteS(Tree_f, (STRING)"static tIdent yyKindToIdent [", 29L);
  587.         Tree_WN(Tree_ClassCount);
  588.         IO_WriteS(Tree_f, (STRING)" + 1];", 6L);
  589.         IO_WriteNl(Tree_f);
  590.         IO_WriteS(Tree_f, (STRING)"static bool yyIsInitialized = false;", 36L);
  591.         IO_WriteNl(Tree_f);
  592.         IO_WriteNl(Tree_f);
  593.         IO_WriteS(Tree_f, (STRING)"static short yyMapToKind", 24L);
  594.         IO_WriteNl(Tree_f);
  595.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  596.         IO_WriteNl(Tree_f);
  597.         IO_WriteS(Tree_f, (STRING)" (char * yys)", 13L);
  598.         IO_WriteNl(Tree_f);
  599.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  600.         IO_WriteNl(Tree_f);
  601.         IO_WriteS(Tree_f, (STRING)" (yys) char * yys;", 18L);
  602.         IO_WriteNl(Tree_f);
  603.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  604.         IO_WriteNl(Tree_f);
  605.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  606.         IO_WriteNl(Tree_f);
  607.         IO_WriteS(Tree_f, (STRING)" register int yyk;", 18L);
  608.         IO_WriteNl(Tree_f);
  609.         IO_WriteS(Tree_f, (STRING)" register tIdent yyi = MakeIdent ((tString) yys, strlen (yys));", 63L);
  610.         IO_WriteNl(Tree_f);
  611.         IO_WriteS(Tree_f, (STRING)" for (yyk = 0; yyk <= ", 22L);
  612.         Tree_WN(Tree_ClassCount);
  613.         IO_WriteS(Tree_f, (STRING)"; yyk ++) {", 11L);
  614.         IO_WriteNl(Tree_f);
  615.         IO_WriteS(Tree_f, (STRING)"  if (yyKindToIdent [yyk] == yyi) return yyk;", 45L);
  616.         IO_WriteNl(Tree_f);
  617.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  618.         IO_WriteNl(Tree_f);
  619.         IO_WriteS(Tree_f, (STRING)" return 0;", 10L);
  620.         IO_WriteNl(Tree_f);
  621.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  622.         IO_WriteNl(Tree_f);
  623.         IO_WriteNl(Tree_f);
  624.         IO_WriteS(Tree_f, (STRING)"static void yyReadNl () { (void) fscanf (yyf, \"\\n\"); }", 54L);
  625.         IO_WriteNl(Tree_f);
  626.         IO_WriteNl(Tree_f);
  627.         IO_WriteS(Tree_f, (STRING)"static tIdent yyReadIdent ()", 28L);
  628.         IO_WriteNl(Tree_f);
  629.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  630.         IO_WriteNl(Tree_f);
  631.         IO_WriteS(Tree_f, (STRING)" char yys [256];", 16L);
  632.         IO_WriteNl(Tree_f);
  633.         IO_WriteS(Tree_f, (STRING)" (void) fscanf (yyf, \"%s\", yys);", 32L);
  634.         IO_WriteNl(Tree_f);
  635.         IO_WriteS(Tree_f, (STRING)" return MakeIdent ((tString) yys, strlen (yys));", 48L);
  636.         IO_WriteNl(Tree_f);
  637.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  638.         IO_WriteNl(Tree_f);
  639.         IO_WriteNl(Tree_f);
  640.         IO_WriteS(Tree_f, (STRING)"static void yyReadHex", 21L);
  641.         IO_WriteNl(Tree_f);
  642.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  643.         IO_WriteNl(Tree_f);
  644.         IO_WriteS(Tree_f, (STRING)" (unsigned char * yyx, int yysize)", 34L);
  645.         IO_WriteNl(Tree_f);
  646.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  647.         IO_WriteNl(Tree_f);
  648.         IO_WriteS(Tree_f, (STRING)" (yyx, yysize) unsigned char * yyx; int yysize;", 47L);
  649.         IO_WriteNl(Tree_f);
  650.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  651.         IO_WriteNl(Tree_f);
  652.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  653.         IO_WriteNl(Tree_f);
  654.         IO_WriteS(Tree_f, (STRING)" register int yyi; int yyk;", 27L);
  655.         IO_WriteNl(Tree_f);
  656.         IO_WriteS(Tree_f, (STRING)" for (yyi = 0; yyi < yysize; yyi ++) { (void) fscanf (yyf, \"%x \", & yyk); yyx [yyi] = yyk; }", 92L);
  657.         IO_WriteNl(Tree_f);
  658.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  659.         IO_WriteNl(Tree_f);
  660.         IO_WriteNl(Tree_f);
  661.         IO_WriteS(Tree_f, (STRING)"static void yySkip () { (void) fscanf (yyf, \" %*s =%*c\"); }", 59L);
  662.         IO_WriteNl(Tree_f);
  663.         IO_WriteNl(Tree_f);
  664.         IO_WriteS(Tree_f, (STRING)"static void yyRead", 18L);
  665.         Tree_WI(Tree_iModule);
  666.         IO_WriteNl(Tree_f);
  667.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  668.         IO_WriteNl(Tree_f);
  669.         IO_WriteS(Tree_f, (STRING)" (yyPtrtTree yyt)", 17L);
  670.         IO_WriteNl(Tree_f);
  671.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  672.         IO_WriteNl(Tree_f);
  673.         IO_WriteS(Tree_f, (STRING)" (yyt) yyPtrtTree yyt;", 22L);
  674.         IO_WriteNl(Tree_f);
  675.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  676.         IO_WriteNl(Tree_f);
  677.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  678.         IO_WriteNl(Tree_f);
  679.         IO_WriteS(Tree_f, (STRING)" static ", 8L);
  680.         Tree_WI(Tree_iMain);
  681.         IO_WriteS(Tree_f, (STRING)"_tLabel yyLabel;", 16L);
  682.         IO_WriteNl(Tree_f);
  683.         IO_WriteS(Tree_f, (STRING)" static ", 8L);
  684.         Tree_WI(Tree_iMain);
  685.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind;", 14L);
  686.         IO_WriteNl(Tree_f);
  687.         IO_WriteS(Tree_f, (STRING)" static char yys [256];", 23L);
  688.         IO_WriteNl(Tree_f);
  689.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  690.         IO_WriteNl(Tree_f);
  691.         IO_WriteS(Tree_f, (STRING)"  switch (getc (yyf)) {", 23L);
  692.         IO_WriteNl(Tree_f);
  693.         IO_WriteS(Tree_f, (STRING)"  case '^':", 11L);
  694.         IO_WriteS(Tree_f, (STRING)" (void) fscanf (yyf, \"%hd\\n\", & yyLabel); * yyt = yyMapToTree (yyLabel); return;", 80L);
  695.         IO_WriteNl(Tree_f);
  696.         IO_WriteS(Tree_f, (STRING)"  case '\\n': case '0':", 22L);
  697.         IO_WriteS(Tree_f, (STRING)" (void) fscanf (yyf, \"%hd%*c %s\\n\", & yyLabel, yys);", 52L);
  698.         IO_WriteNl(Tree_f);
  699.         IO_WriteS(Tree_f, (STRING)"   yyKind = yyMapToKind (yys); * yyt = Make", 43L);
  700.         Tree_WI(Tree_iMain);
  701.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  702.         IO_WriteNl(Tree_f);
  703.         IO_WriteS(Tree_f, (STRING)"   if (yyLabel != yyMapToLabel (* yyt)) { (void) fputs (\"", 57L);
  704.         Tree_WI(Tree_iModule);
  705.         IO_WriteS(Tree_f, (STRING)": error in Read", 15L);
  706.         Tree_WI(Tree_iModule);
  707.         IO_WriteS(Tree_f, (STRING)"\\n\", stderr); ", 14L);
  708.         Tree_WI(Tree_iMain);
  709.         IO_WriteS(Tree_f, (STRING)"_Exit (); } break;", 18L);
  710.         IO_WriteNl(Tree_f);
  711.         IO_WriteS(Tree_f, (STRING)"  default: ;", 12L);
  712.         IO_WriteNl(Tree_f);
  713.         IO_WriteS(Tree_f, (STRING)"   (void) fscanf (yyf, \"%s\", yys);", 34L);
  714.         IO_WriteNl(Tree_f);
  715.         IO_WriteS(Tree_f, (STRING)"   yyKind = yyMapToKind (yys);", 30L);
  716.         IO_WriteNl(Tree_f);
  717.         IO_WriteS(Tree_f, (STRING)"   if (yyKind == 0) { * yyt = ", 30L);
  718.         Tree_WI(Tree_iNoTree);
  719.         IO_WriteS(Tree_f, (STRING)"; return; }", 11L);
  720.         IO_WriteNl(Tree_f);
  721.         IO_WriteS(Tree_f, (STRING)"   * yyt = Make", 15L);
  722.         Tree_WI(Tree_iMain);
  723.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  724.         IO_WriteNl(Tree_f);
  725.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  726.         IO_WriteNl(Tree_f);
  727.         IO_WriteNl(Tree_f);
  728.         IO_WriteS(Tree_f, (STRING)"  switch (yyKind) {", 19L);
  729.         IO_WriteNl(Tree_f);
  730.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)ReadAttributes);
  731.         IO_WriteS(Tree_f, (STRING)"  default: return;", 18L);
  732.         IO_WriteNl(Tree_f);
  733.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  734.         IO_WriteNl(Tree_f);
  735.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  736.         IO_WriteNl(Tree_f);
  737.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  738.         IO_WriteNl(Tree_f);
  739.         IO_WriteNl(Tree_f);
  740.         Tree_WI(Tree_itTree);
  741.         IO_WriteS(Tree_f, (STRING)" Read", 5L);
  742.         Tree_WI(Tree_iModule);
  743.         IO_WriteNl(Tree_f);
  744.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  745.         IO_WriteNl(Tree_f);
  746.         IO_WriteS(Tree_f, (STRING)" (FILE * yyyf)", 14L);
  747.         IO_WriteNl(Tree_f);
  748.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  749.         IO_WriteNl(Tree_f);
  750.         IO_WriteS(Tree_f, (STRING)" (yyyf) FILE * yyyf;", 20L);
  751.         IO_WriteNl(Tree_f);
  752.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  753.         IO_WriteNl(Tree_f);
  754.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  755.         IO_WriteNl(Tree_f);
  756.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  757.         Tree_WI(Tree_itTree);
  758.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  759.         IO_WriteNl(Tree_f);
  760.         IO_WriteS(Tree_f, (STRING)" yyf = yyyf;", 12L);
  761.         IO_WriteNl(Tree_f);
  762.         IO_WriteS(Tree_f, (STRING)" if (yyRecursionLevel ++ == 0) yyLabelCount = 0;", 48L);
  763.         IO_WriteNl(Tree_f);
  764.         IO_WriteS(Tree_f, (STRING)" if (! yyIsInitialized) {", 25L);
  765.         IO_WriteNl(Tree_f);
  766.         IO_WriteS(Tree_f, (STRING)"  register int yyi;", 19L);
  767.         IO_WriteNl(Tree_f);
  768.         IO_WriteS(Tree_f, (STRING)"  for (yyi = 0; yyi <= ", 23L);
  769.         Tree_WN(Tree_ClassCount);
  770.         IO_WriteS(Tree_f, (STRING)"; yyi ++)", 9L);
  771.         IO_WriteNl(Tree_f);
  772.         IO_WriteS(Tree_f, (STRING)"   yyKindToIdent [yyi] = MakeIdent ((tString) ", 46L);
  773.         Tree_WI(Tree_iMain);
  774.         IO_WriteS(Tree_f, (STRING)"_NodeName [yyi], strlen (", 25L);
  775.         Tree_WI(Tree_iMain);
  776.         IO_WriteS(Tree_f, (STRING)"_NodeName [yyi]));", 18L);
  777.         IO_WriteNl(Tree_f);
  778.         IO_WriteS(Tree_f, (STRING)"  yyIsInitialized = true;", 25L);
  779.         IO_WriteNl(Tree_f);
  780.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  781.         IO_WriteNl(Tree_f);
  782.         IO_WriteS(Tree_f, (STRING)" yyRead", 7L);
  783.         Tree_WI(Tree_iModule);
  784.         IO_WriteS(Tree_f, (STRING)" (& yyt);", 9L);
  785.         IO_WriteNl(Tree_f);
  786.         IO_WriteS(Tree_f, (STRING)" yyRecursionLevel --;", 21L);
  787.         IO_WriteNl(Tree_f);
  788.         IO_WriteS(Tree_f, (STRING)" return yyt;", 12L);
  789.         IO_WriteNl(Tree_f);
  790.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  791.         IO_WriteNl(Tree_f);
  792.         IO_WriteNl(Tree_f);
  793.       }
  794.       IO_WriteS(Tree_f, (STRING)"# define yyNil    0374", 19L);
  795.       IO_WriteNl(Tree_f);
  796.       IO_WriteS(Tree_f, (STRING)"# define yyNoLabel    0375", 23L);
  797.       IO_WriteNl(Tree_f);
  798.       IO_WriteS(Tree_f, (STRING)"# define yyLabelDef    0376", 24L);
  799.       IO_WriteNl(Tree_f);
  800.       IO_WriteS(Tree_f, (STRING)"# define yyLabelUse    0377", 24L);
  801.       IO_WriteNl(Tree_f);
  802.       IO_WriteNl(Tree_f);
  803.       if (Sets_IsElement(ORD('p'), &Tree_Options)) {
  804.         IO_WriteS(Tree_f, (STRING)"static void yyPut", 17L);
  805.         IO_WriteNl(Tree_f);
  806.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  807.         IO_WriteNl(Tree_f);
  808.         IO_WriteS(Tree_f, (STRING)" (char * yyx, int yysize)", 25L);
  809.         IO_WriteNl(Tree_f);
  810.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  811.         IO_WriteNl(Tree_f);
  812.         IO_WriteS(Tree_f, (STRING)" (yyx, yysize) char * yyx; int yysize;", 38L);
  813.         IO_WriteNl(Tree_f);
  814.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  815.         IO_WriteNl(Tree_f);
  816.         IO_WriteS(Tree_f, (STRING)"{ (void) fwrite (yyx, 1, yysize, yyf); }", 40L);
  817.         IO_WriteNl(Tree_f);
  818.         IO_WriteNl(Tree_f);
  819.         IO_WriteS(Tree_f, (STRING)"static void yyPutIdent", 22L);
  820.         IO_WriteNl(Tree_f);
  821.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  822.         IO_WriteNl(Tree_f);
  823.         IO_WriteS(Tree_f, (STRING)" (tIdent yyi)", 13L);
  824.         IO_WriteNl(Tree_f);
  825.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  826.         IO_WriteNl(Tree_f);
  827.         IO_WriteS(Tree_f, (STRING)" (yyi) tIdent yyi;", 18L);
  828.         IO_WriteNl(Tree_f);
  829.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  830.         IO_WriteNl(Tree_f);
  831.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  832.         IO_WriteNl(Tree_f);
  833.         IO_WriteS(Tree_f, (STRING)" char yys [256];", 16L);
  834.         IO_WriteNl(Tree_f);
  835.         IO_WriteS(Tree_f, (STRING)" GetString (yyi, (tString) yys);", 32L);
  836.         IO_WriteNl(Tree_f);
  837.         IO_WriteS(Tree_f, (STRING)" (void) fprintf (yyf, \"%s\\n\", yys);", 35L);
  838.         IO_WriteNl(Tree_f);
  839.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  840.         IO_WriteNl(Tree_f);
  841.         IO_WriteNl(Tree_f);
  842.         IO_WriteS(Tree_f, (STRING)"static void yyPut", 17L);
  843.         Tree_WI(Tree_iModule);
  844.         IO_WriteNl(Tree_f);
  845.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  846.         IO_WriteNl(Tree_f);
  847.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  848.         Tree_WI(Tree_itTree);
  849.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  850.         IO_WriteNl(Tree_f);
  851.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  852.         IO_WriteNl(Tree_f);
  853.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  854.         Tree_WI(Tree_itTree);
  855.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  856.         IO_WriteNl(Tree_f);
  857.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  858.         IO_WriteNl(Tree_f);
  859.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  860.         IO_WriteNl(Tree_f);
  861.         IO_WriteS(Tree_f, (STRING)" static ", 8L);
  862.         Tree_WI(Tree_iMain);
  863.         IO_WriteS(Tree_f, (STRING)"_tLabel yyLabel;", 16L);
  864.         IO_WriteNl(Tree_f);
  865.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  866.         IO_WriteNl(Tree_f);
  867.         IO_WriteS(Tree_f, (STRING)"  if (yyt == ", 13L);
  868.         Tree_WI(Tree_iNoTree);
  869.         IO_WriteS(Tree_f, (STRING)") {", 3L);
  870.         IO_WriteNl(Tree_f);
  871.         IO_WriteS(Tree_f, (STRING)"   (void) putc (yyNil, yyf); return;", 36L);
  872.         IO_WriteNl(Tree_f);
  873.         IO_WriteS(Tree_f, (STRING)"  } else if (yyt->yyHead.yyMark == 0) {", 39L);
  874.         IO_WriteNl(Tree_f);
  875.         IO_WriteS(Tree_f, (STRING)"   (void) putc (yyLabelUse, yyf); yyLabel = yyMapToLabel (yyt); yyPut ((char *) & yyLabel, sizeof (yyLabel)); return;", 117L);
  876.         IO_WriteNl(Tree_f);
  877.         IO_WriteS(Tree_f, (STRING)"  } else if (yyt->yyHead.yyMark > 1) {", 38L);
  878.         IO_WriteNl(Tree_f);
  879.         IO_WriteS(Tree_f, (STRING)"   (void) putc (yyLabelDef, yyf); yyLabel = yyMapToLabel (yyt); yyPut ((char *) & yyLabel, sizeof (yyLabel));", 109L);
  880.         IO_WriteNl(Tree_f);
  881.         if (Tree_ClassCount > 251) {
  882.           IO_WriteS(Tree_f, (STRING)"   yyPut ((char *) & yyt->Kind, sizeof (", 40L);
  883.           Tree_WI(Tree_iMain);
  884.           IO_WriteS(Tree_f, (STRING)"_tKind));", 9L);
  885.           IO_WriteNl(Tree_f);
  886.           IO_WriteS(Tree_f, (STRING)"  } else if (yyt->Kind > 251) {", 31L);
  887.           IO_WriteNl(Tree_f);
  888.           IO_WriteS(Tree_f, (STRING)"   (void) putc (yyNoLabel, yyf); yyPut ((char *) & yyt->Kind, sizeof (", 70L);
  889.           Tree_WI(Tree_iMain);
  890.           IO_WriteS(Tree_f, (STRING)"_tKind));", 9L);
  891.           IO_WriteNl(Tree_f);
  892.         } else {
  893.           IO_WriteS(Tree_f, (STRING)"   (void) putc ((char) yyt->Kind, yyf);", 39L);
  894.           IO_WriteNl(Tree_f);
  895.         }
  896.         IO_WriteS(Tree_f, (STRING)"  } else {", 10L);
  897.         IO_WriteNl(Tree_f);
  898.         IO_WriteS(Tree_f, (STRING)"   (void) putc ((char) yyt->Kind, yyf);", 39L);
  899.         IO_WriteNl(Tree_f);
  900.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  901.         IO_WriteNl(Tree_f);
  902.         IO_WriteS(Tree_f, (STRING)"  yyt->yyHead.yyMark = 0;", 25L);
  903.         IO_WriteNl(Tree_f);
  904.         IO_WriteNl(Tree_f);
  905.         IO_WriteS(Tree_f, (STRING)"  switch (yyt->Kind) {", 22L);
  906.         IO_WriteNl(Tree_f);
  907.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)PutAttributes);
  908.         IO_WriteS(Tree_f, (STRING)"  default: return;", 18L);
  909.         IO_WriteNl(Tree_f);
  910.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  911.         IO_WriteNl(Tree_f);
  912.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  913.         IO_WriteNl(Tree_f);
  914.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  915.         IO_WriteNl(Tree_f);
  916.         IO_WriteNl(Tree_f);
  917.         IO_WriteS(Tree_f, (STRING)"void Put", 8L);
  918.         Tree_WI(Tree_iModule);
  919.         IO_WriteNl(Tree_f);
  920.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  921.         IO_WriteNl(Tree_f);
  922.         IO_WriteS(Tree_f, (STRING)" (FILE * yyyf, ", 15L);
  923.         Tree_WI(Tree_itTree);
  924.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  925.         IO_WriteNl(Tree_f);
  926.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  927.         IO_WriteNl(Tree_f);
  928.         IO_WriteS(Tree_f, (STRING)" (yyyf, yyt) FILE * yyyf; ", 26L);
  929.         Tree_WI(Tree_itTree);
  930.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  931.         IO_WriteNl(Tree_f);
  932.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  933.         IO_WriteNl(Tree_f);
  934.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  935.         IO_WriteNl(Tree_f);
  936.         IO_WriteS(Tree_f, (STRING)" yyf = yyyf;", 12L);
  937.         IO_WriteNl(Tree_f);
  938.         IO_WriteS(Tree_f, (STRING)" if (yyRecursionLevel ++ == 0) yyLabelCount = 0;", 48L);
  939.         IO_WriteNl(Tree_f);
  940.         IO_WriteS(Tree_f, (STRING)" yyMark (yyt);", 14L);
  941.         IO_WriteNl(Tree_f);
  942.         IO_WriteS(Tree_f, (STRING)" yyPut", 6L);
  943.         Tree_WI(Tree_iModule);
  944.         IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  945.         IO_WriteNl(Tree_f);
  946.         IO_WriteS(Tree_f, (STRING)" yyRecursionLevel --;", 21L);
  947.         IO_WriteNl(Tree_f);
  948.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  949.         IO_WriteNl(Tree_f);
  950.         IO_WriteNl(Tree_f);
  951.       }
  952.       if (Sets_IsElement(ORD('g'), &Tree_Options)) {
  953.         IO_WriteS(Tree_f, (STRING)"static void yyGet", 17L);
  954.         IO_WriteNl(Tree_f);
  955.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  956.         IO_WriteNl(Tree_f);
  957.         IO_WriteS(Tree_f, (STRING)" (char * yyx, int yysize)", 25L);
  958.         IO_WriteNl(Tree_f);
  959.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  960.         IO_WriteNl(Tree_f);
  961.         IO_WriteS(Tree_f, (STRING)" (yyx, yysize) char * yyx; int yysize;", 38L);
  962.         IO_WriteNl(Tree_f);
  963.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  964.         IO_WriteNl(Tree_f);
  965.         IO_WriteS(Tree_f, (STRING)"{ (void) fread (yyx, 1, yysize, yyf); }", 39L);
  966.         IO_WriteNl(Tree_f);
  967.         IO_WriteNl(Tree_f);
  968.         IO_WriteS(Tree_f, (STRING)"static void yyGetIdent", 22L);
  969.         IO_WriteNl(Tree_f);
  970.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  971.         IO_WriteNl(Tree_f);
  972.         IO_WriteS(Tree_f, (STRING)" (tIdent * yyi)", 15L);
  973.         IO_WriteNl(Tree_f);
  974.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  975.         IO_WriteNl(Tree_f);
  976.         IO_WriteS(Tree_f, (STRING)" (yyi) tIdent * yyi;", 20L);
  977.         IO_WriteNl(Tree_f);
  978.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  979.         IO_WriteNl(Tree_f);
  980.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  981.         IO_WriteNl(Tree_f);
  982.         IO_WriteS(Tree_f, (STRING)" char yys [256];", 16L);
  983.         IO_WriteNl(Tree_f);
  984.         IO_WriteS(Tree_f, (STRING)" (void) fscanf (yyf, \"%s%*c\", yys);", 35L);
  985.         IO_WriteNl(Tree_f);
  986.         IO_WriteS(Tree_f, (STRING)" * yyi = MakeIdent ((tString) yys, strlen (yys));", 49L);
  987.         IO_WriteNl(Tree_f);
  988.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  989.         IO_WriteNl(Tree_f);
  990.         IO_WriteNl(Tree_f);
  991.         IO_WriteS(Tree_f, (STRING)"static void yyGet", 17L);
  992.         Tree_WI(Tree_iModule);
  993.         IO_WriteNl(Tree_f);
  994.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  995.         IO_WriteNl(Tree_f);
  996.         IO_WriteS(Tree_f, (STRING)" (yyPtrtTree yyt)", 17L);
  997.         IO_WriteNl(Tree_f);
  998.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  999.         IO_WriteNl(Tree_f);
  1000.         IO_WriteS(Tree_f, (STRING)" (yyt) yyPtrtTree yyt;", 22L);
  1001.         IO_WriteNl(Tree_f);
  1002.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1003.         IO_WriteNl(Tree_f);
  1004.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1005.         IO_WriteNl(Tree_f);
  1006.         IO_WriteS(Tree_f, (STRING)" static ", 8L);
  1007.         Tree_WI(Tree_iMain);
  1008.         IO_WriteS(Tree_f, (STRING)"_tLabel yyLabel;", 16L);
  1009.         IO_WriteNl(Tree_f);
  1010.         IO_WriteS(Tree_f, (STRING)" static ", 8L);
  1011.         Tree_WI(Tree_iMain);
  1012.         IO_WriteS(Tree_f, (STRING)"_tKind yyKind;", 14L);
  1013.         IO_WriteNl(Tree_f);
  1014.         IO_WriteS(Tree_f, (STRING)" for (;;) {", 11L);
  1015.         IO_WriteNl(Tree_f);
  1016.         IO_WriteS(Tree_f, (STRING)"  switch (yyKind = getc (yyf)) {", 32L);
  1017.         IO_WriteNl(Tree_f);
  1018.         IO_WriteS(Tree_f, (STRING)"  case yyNil        : * yyt = ", 24L);
  1019.         Tree_WI(Tree_iNoTree);
  1020.         IO_WriteS(Tree_f, (STRING)"; return;", 9L);
  1021.         IO_WriteNl(Tree_f);
  1022.         IO_WriteS(Tree_f, (STRING)"  case yyLabelUse    : yyGet ((char *) & yyLabel, sizeof (yyLabel));", 65L);
  1023.         IO_WriteNl(Tree_f);
  1024.         IO_WriteS(Tree_f, (STRING)"   * yyt = yyMapToTree (yyLabel); return;", 41L);
  1025.         IO_WriteNl(Tree_f);
  1026.         IO_WriteS(Tree_f, (STRING)"  case yyLabelDef    : yyGet ((char *) & yyLabel, sizeof (yyLabel));", 65L);
  1027.         IO_WriteNl(Tree_f);
  1028.         if (Tree_ClassCount > 251) {
  1029.           IO_WriteS(Tree_f, (STRING)"   yyGet ((char *) & yyKind, sizeof (yyKind));", 46L);
  1030.           IO_WriteNl(Tree_f);
  1031.         } else {
  1032.           IO_WriteS(Tree_f, (STRING)"   yyKind = getc (yyf);", 23L);
  1033.         }
  1034.         IO_WriteS(Tree_f, (STRING)"   * yyt = Make", 15L);
  1035.         Tree_WI(Tree_iMain);
  1036.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  1037.         IO_WriteNl(Tree_f);
  1038.         IO_WriteS(Tree_f, (STRING)"   if (yyLabel != yyMapToLabel (* yyt)) { (void) fputs (\"", 57L);
  1039.         Tree_WI(Tree_iModule);
  1040.         IO_WriteS(Tree_f, (STRING)": error in Get", 14L);
  1041.         Tree_WI(Tree_iModule);
  1042.         IO_WriteS(Tree_f, (STRING)"\\n\", stderr); ", 14L);
  1043.         Tree_WI(Tree_iMain);
  1044.         IO_WriteS(Tree_f, (STRING)"_Exit (); } break;", 18L);
  1045.         IO_WriteNl(Tree_f);
  1046.         if (Tree_ClassCount > 251) {
  1047.           IO_WriteS(Tree_f, (STRING)"  case yyNoLabel    : yyGet ((char *) & yyKind, sizeof (yyKind));", 62L);
  1048.           IO_WriteNl(Tree_f);
  1049.           IO_WriteS(Tree_f, (STRING)"   * yyt = Make", 15L);
  1050.           Tree_WI(Tree_iMain);
  1051.           IO_WriteS(Tree_f, (STRING)" (yyKind); break;", 17L);
  1052.           IO_WriteNl(Tree_f);
  1053.         }
  1054.         IO_WriteS(Tree_f, (STRING)"  default    : * yyt = Make", 24L);
  1055.         Tree_WI(Tree_iMain);
  1056.         IO_WriteS(Tree_f, (STRING)" (yyKind);", 10L);
  1057.         IO_WriteNl(Tree_f);
  1058.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1059.         IO_WriteNl(Tree_f);
  1060.         IO_WriteNl(Tree_f);
  1061.         IO_WriteS(Tree_f, (STRING)"  switch (yyKind) {", 19L);
  1062.         IO_WriteNl(Tree_f);
  1063.         Tree_ForallClasses(W_1->Classes, (Tree_ProcOfT)GetAttributes);
  1064.         IO_WriteS(Tree_f, (STRING)"  default: return;", 18L);
  1065.         IO_WriteNl(Tree_f);
  1066.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1067.         IO_WriteNl(Tree_f);
  1068.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1069.         IO_WriteNl(Tree_f);
  1070.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1071.         IO_WriteNl(Tree_f);
  1072.         IO_WriteNl(Tree_f);
  1073.         Tree_WI(Tree_itTree);
  1074.         IO_WriteS(Tree_f, (STRING)" Get", 4L);
  1075.         Tree_WI(Tree_iModule);
  1076.         IO_WriteNl(Tree_f);
  1077.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1078.         IO_WriteNl(Tree_f);
  1079.         IO_WriteS(Tree_f, (STRING)" (FILE * yyyf)", 14L);
  1080.         IO_WriteNl(Tree_f);
  1081.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1082.         IO_WriteNl(Tree_f);
  1083.         IO_WriteS(Tree_f, (STRING)" (yyyf) FILE * yyyf;", 20L);
  1084.         IO_WriteNl(Tree_f);
  1085.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1086.         IO_WriteNl(Tree_f);
  1087.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1088.         IO_WriteNl(Tree_f);
  1089.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1090.         Tree_WI(Tree_itTree);
  1091.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1092.         IO_WriteNl(Tree_f);
  1093.         IO_WriteS(Tree_f, (STRING)" yyf = yyyf;", 12L);
  1094.         IO_WriteNl(Tree_f);
  1095.         IO_WriteS(Tree_f, (STRING)" if (yyRecursionLevel ++ == 0) yyLabelCount = 0;", 48L);
  1096.         IO_WriteNl(Tree_f);
  1097.         IO_WriteS(Tree_f, (STRING)" yyGet", 6L);
  1098.         Tree_WI(Tree_iModule);
  1099.         IO_WriteS(Tree_f, (STRING)" (& yyt);", 9L);
  1100.         IO_WriteNl(Tree_f);
  1101.         IO_WriteS(Tree_f, (STRING)" yyRecursionLevel --;", 21L);
  1102.         IO_WriteNl(Tree_f);
  1103.         IO_WriteS(Tree_f, (STRING)" return yyt;", 12L);
  1104.         IO_WriteNl(Tree_f);
  1105.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1106.         IO_WriteNl(Tree_f);
  1107.         IO_WriteNl(Tree_f);
  1108.       }
  1109.       return;
  1110.     }
  1111.   }
  1112. }
  1113.  
  1114. static void WriteNodeName
  1115. # ifdef __STDC__
  1116. (Tree_tTree t)
  1117. # else
  1118. (t)
  1119. Tree_tTree t;
  1120. # endif
  1121. {
  1122.   struct S_4 yyTempo;
  1123.  
  1124.   if (t == Tree_NoTree) {
  1125.     return;
  1126.   }
  1127.   if (t->U_1.V_1.Kind == Tree_Class) {
  1128.     {
  1129.       register Tree_yClass *W_2 = &t->U_1.V_5.Class;
  1130.  
  1131.       if ((Tree_NoCodeClass & W_2->Properties) == 0X0L) {
  1132.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1133.         Tree_WI(W_2->Name);
  1134.         IO_WriteS(Tree_f, (STRING)": (void) fputs (", 16L);
  1135.         Tree_WI(Tree_iMain);
  1136.         IO_WriteS(Tree_f, (STRING)"_NodeName [k", 12L);
  1137.         Tree_WI(W_2->Name);
  1138.         IO_WriteS(Tree_f, (STRING)"], yyf); (void) fputc ('\\n', yyf);", 34L);
  1139.         IO_WriteNl(Tree_f);
  1140.         if (((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_2->Properties) != 0X0L) {
  1141.           IO_WriteS(Tree_f, (STRING)" yWriteNode", 11L);
  1142.           Tree_WI(W_2->Name);
  1143.           IO_WriteS(Tree_f, (STRING)" (yyt);", 7L);
  1144.         }
  1145.         IO_WriteS(Tree_f, (STRING)" break;", 7L);
  1146.         IO_WriteNl(Tree_f);
  1147.       }
  1148.       return;
  1149.     }
  1150.   }
  1151. }
  1152.  
  1153. static void WriteNode
  1154. # ifdef __STDC__
  1155. (Tree_tTree t)
  1156. # else
  1157. (t)
  1158. Tree_tTree t;
  1159. # endif
  1160. {
  1161.   struct S_5 yyTempo;
  1162.  
  1163.   if (t == Tree_NoTree) {
  1164.     return;
  1165.   }
  1166.   if (t->U_1.V_1.Kind == Tree_Class) {
  1167.     {
  1168.       register Tree_yClass *W_3 = &t->U_1.V_5.Class;
  1169.  
  1170.       if ((Tree_NoCodeClass & W_3->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_3->Properties) != 0X0L) {
  1171.         IO_WriteS(Tree_f, (STRING)"static void yWriteNode", 22L);
  1172.         Tree_WI(W_3->Name);
  1173.         IO_WriteNl(Tree_f);
  1174.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1175.         IO_WriteNl(Tree_f);
  1176.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1177.         Tree_WI(Tree_itTree);
  1178.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1179.         IO_WriteNl(Tree_f);
  1180.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1181.         IO_WriteNl(Tree_f);
  1182.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1183.         Tree_WI(Tree_itTree);
  1184.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1185.         IO_WriteNl(Tree_f);
  1186.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1187.         IO_WriteNl(Tree_f);
  1188.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1189.         IO_WriteNl(Tree_f);
  1190.         if (W_3->BaseClass->U_1.V_1.Kind == Tree_Class && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_3->BaseClass->U_1.V_5.Class.Properties) != 0X0L) {
  1191.           IO_WriteS(Tree_f, (STRING)" yWriteNode", 11L);
  1192.           Tree_WI(W_3->BaseClass->U_1.V_5.Class.Name);
  1193.           IO_WriteS(Tree_f, (STRING)" (yyt); ", 8L);
  1194.           IO_WriteNl(Tree_f);
  1195.         }
  1196.         iClassName = W_3->Name;
  1197.         Tree_ForallAttributes(W_3->Attributes, (Tree_ProcOfT)WriteNode);
  1198.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1199.         IO_WriteNl(Tree_f);
  1200.         IO_WriteNl(Tree_f);
  1201.       }
  1202.       return;
  1203.     }
  1204.   }
  1205.   if (t->U_1.V_1.Kind == Tree_Child) {
  1206.     {
  1207.       register Tree_yChild *W_4 = &t->U_1.V_9.Child;
  1208.  
  1209.       IO_WriteS(Tree_f, (STRING)" yyWriteSelector (\"", 19L);
  1210.       Tree_WI(W_4->Name);
  1211.       IO_WriteS(Tree_f, (STRING)"\");", 3L);
  1212.       IO_WriteS(Tree_f, (STRING)" yyWriteAdr (yyt->", 18L);
  1213.       Tree_WI(iClassName);
  1214.       IO_WriteS(Tree_f, (STRING)".", 1L);
  1215.       Tree_WI(W_4->Name);
  1216.       IO_WriteS(Tree_f, (STRING)");", 2L);
  1217.       IO_WriteNl(Tree_f);
  1218.       return;
  1219.     }
  1220.   }
  1221.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1222.     {
  1223.       register Tree_yAttribute *W_5 = &t->U_1.V_10.Attribute;
  1224.  
  1225.       if ((Tree_NoCodeAttr & W_5->Properties) == 0X0L) {
  1226.         IO_WriteS(Tree_f, (STRING)" yyWriteSelector (\"", 19L);
  1227.         Tree_WI(W_5->Name);
  1228.         IO_WriteS(Tree_f, (STRING)"\"); write", 9L);
  1229.         Tree_WI(W_5->Type);
  1230.         IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  1231.         Tree_WI(iClassName);
  1232.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1233.         Tree_WI(W_5->Name);
  1234.         IO_WriteS(Tree_f, (STRING)") yyWriteNl ();", 15L);
  1235.         IO_WriteNl(Tree_f);
  1236.       }
  1237.       return;
  1238.     }
  1239.   }
  1240. }
  1241.  
  1242. static void Mark
  1243. # ifdef __STDC__
  1244. (Tree_tTree t)
  1245. # else
  1246. (t)
  1247. Tree_tTree t;
  1248. # endif
  1249. {
  1250.   struct S_6 yyTempo;
  1251.  
  1252.   if (t == Tree_NoTree) {
  1253.     return;
  1254.   }
  1255.   if (t->U_1.V_1.Kind == Tree_Class) {
  1256.     {
  1257.       register Tree_yClass *W_6 = &t->U_1.V_5.Class;
  1258.  
  1259.       if ((Tree_NoCodeClass & W_6->Properties) == 0X0L && IN(Tree_HasChildren, W_6->Properties)) {
  1260.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1261.         Tree_WI(W_6->Name);
  1262.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1263.         IO_WriteNl(Tree_f);
  1264.         TreeC2_GetIterator(t);
  1265.         iClassName = W_6->Name;
  1266.         Tree_ForallAttributes(t, (Tree_ProcOfT)Mark);
  1267.         if (TreeC2_Iterator == Tree_NoTree) {
  1268.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  1269.           IO_WriteNl(Tree_f);
  1270.         } else {
  1271.           IO_WriteS(Tree_f, (STRING)"yyt = yyt->", 11L);
  1272.           Tree_WI(iClassName);
  1273.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1274.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  1275.           IO_WriteS(Tree_f, (STRING)"; break;", 8L);
  1276.           IO_WriteNl(Tree_f);
  1277.         }
  1278.       }
  1279.       return;
  1280.     }
  1281.   }
  1282.   if (t->U_1.V_1.Kind == Tree_Child) {
  1283.     {
  1284.       register Tree_yChild *W_7 = &t->U_1.V_9.Child;
  1285.  
  1286.       if (t != TreeC2_Iterator) {
  1287.         IO_WriteS(Tree_f, (STRING)"yyMark (yyt->", 13L);
  1288.         Tree_WI(iClassName);
  1289.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1290.         Tree_WI(W_7->Name);
  1291.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1292.         IO_WriteNl(Tree_f);
  1293.       }
  1294.       return;
  1295.     }
  1296.   }
  1297. }
  1298.  
  1299. static void WriteClassName
  1300. # ifdef __STDC__
  1301. (Tree_tTree t)
  1302. # else
  1303. (t)
  1304. Tree_tTree t;
  1305. # endif
  1306. {
  1307.   struct S_7 yyTempo;
  1308.  
  1309.   if (t == Tree_NoTree) {
  1310.     return;
  1311.   }
  1312.   if (t->U_1.V_1.Kind == Tree_Class) {
  1313.     {
  1314.       register Tree_yClass *W_8 = &t->U_1.V_5.Class;
  1315.  
  1316.       if ((Tree_NoCodeClass & W_8->Properties) == 0X0L) {
  1317.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1318.         Tree_WI(W_8->Name);
  1319.         IO_WriteS(Tree_f, (STRING)": ", 2L);
  1320.         if (((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_8->Properties) != 0X0L) {
  1321.           IO_WriteS(Tree_f, (STRING)"yWrite", 6L);
  1322.           Tree_WI(W_8->Name);
  1323.           IO_WriteS(Tree_f, (STRING)" (yyt); ", 8L);
  1324.           TreeC2_GetIterator(t);
  1325.           if (TreeC2_Iterator == Tree_NoTree) {
  1326.             IO_WriteS(Tree_f, (STRING)"goto yyExit;", 12L);
  1327.             IO_WriteNl(Tree_f);
  1328.           } else {
  1329.             IO_WriteS(Tree_f, (STRING)"yyIndentSelector (\"", 19L);
  1330.             Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  1331.             IO_WriteS(Tree_f, (STRING)"\"); ", 4L);
  1332.             IO_WriteS(Tree_f, (STRING)"yyt = yyt->", 11L);
  1333.             Tree_WI(W_8->Name);
  1334.             IO_WriteS(Tree_f, (STRING)".", 1L);
  1335.             Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  1336.             IO_WriteS(Tree_f, (STRING)"; break;", 8L);
  1337.             IO_WriteNl(Tree_f);
  1338.           }
  1339.         } else {
  1340.           IO_WriteS(Tree_f, (STRING)"(void) fputs (", 14L);
  1341.           Tree_WI(Tree_iMain);
  1342.           IO_WriteS(Tree_f, (STRING)"_NodeName [k", 12L);
  1343.           Tree_WI(W_8->Name);
  1344.           IO_WriteS(Tree_f, (STRING)"], yyf); (void) fputc ('\\n', yyf); goto yyExit;", 47L);
  1345.           IO_WriteNl(Tree_f);
  1346.         }
  1347.       }
  1348.       return;
  1349.     }
  1350.   }
  1351. }
  1352.  
  1353. static void WriteAttributes
  1354. # ifdef __STDC__
  1355. (Tree_tTree t)
  1356. # else
  1357. (t)
  1358. Tree_tTree t;
  1359. # endif
  1360. {
  1361.   struct S_8 yyTempo;
  1362.  
  1363.   if (t == Tree_NoTree) {
  1364.     return;
  1365.   }
  1366.   if (t->U_1.V_1.Kind == Tree_Class) {
  1367.     {
  1368.       register Tree_yClass *W_9 = &t->U_1.V_5.Class;
  1369.  
  1370.       if ((Tree_NoCodeClass & W_9->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_9->Properties) != 0X0L) {
  1371.         IO_WriteS(Tree_f, (STRING)"static void yWrite", 18L);
  1372.         Tree_WI(W_9->Name);
  1373.         IO_WriteNl(Tree_f);
  1374.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1375.         IO_WriteNl(Tree_f);
  1376.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  1377.         Tree_WI(Tree_itTree);
  1378.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1379.         IO_WriteNl(Tree_f);
  1380.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1381.         IO_WriteNl(Tree_f);
  1382.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  1383.         Tree_WI(Tree_itTree);
  1384.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1385.         IO_WriteNl(Tree_f);
  1386.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1387.         IO_WriteNl(Tree_f);
  1388.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1389.         IO_WriteNl(Tree_f);
  1390.         IO_WriteS(Tree_f, (STRING)" (void) fputs (", 15L);
  1391.         Tree_WI(Tree_iMain);
  1392.         IO_WriteS(Tree_f, (STRING)"_NodeName [k", 12L);
  1393.         Tree_WI(W_9->Name);
  1394.         IO_WriteS(Tree_f, (STRING)"], yyf); (void) fputc ('\\n', yyf);", 34L);
  1395.         IO_WriteNl(Tree_f);
  1396.         TreeC2_GetIterator(t);
  1397.         iClassName = W_9->Name;
  1398.         Tree_ForallAttributes(t, (Tree_ProcOfT)WriteAttributes);
  1399.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1400.         IO_WriteNl(Tree_f);
  1401.         IO_WriteNl(Tree_f);
  1402.       }
  1403.       return;
  1404.     }
  1405.   }
  1406.   if (t->U_1.V_1.Kind == Tree_Child) {
  1407.     {
  1408.       register Tree_yChild *W_10 = &t->U_1.V_9.Child;
  1409.  
  1410.       if (t != TreeC2_Iterator) {
  1411.         IO_WriteS(Tree_f, (STRING)" yyIndentSelectorTree (\"", 24L);
  1412.         Tree_WI(W_10->Name);
  1413.         IO_WriteS(Tree_f, (STRING)"\", yyt->", 8L);
  1414.         Tree_WI(iClassName);
  1415.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1416.         Tree_WI(W_10->Name);
  1417.         IO_WriteS(Tree_f, (STRING)");", 2L);
  1418.         IO_WriteNl(Tree_f);
  1419.       }
  1420.       return;
  1421.     }
  1422.   }
  1423.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1424.     {
  1425.       register Tree_yAttribute *W_11 = &t->U_1.V_10.Attribute;
  1426.  
  1427.       if ((Tree_NoCodeAttr & W_11->Properties) == 0X0L) {
  1428.         IO_WriteS(Tree_f, (STRING)" yyIndentSelector (\"", 20L);
  1429.         Tree_WI(W_11->Name);
  1430.         IO_WriteS(Tree_f, (STRING)"\"); ", 4L);
  1431.         IO_WriteS(Tree_f, (STRING)"write", 5L);
  1432.         Tree_WI(W_11->Type);
  1433.         IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  1434.         Tree_WI(iClassName);
  1435.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1436.         Tree_WI(W_11->Name);
  1437.         IO_WriteS(Tree_f, (STRING)") yyWriteNl ();", 15L);
  1438.         IO_WriteNl(Tree_f);
  1439.       }
  1440.       return;
  1441.     }
  1442.   }
  1443. }
  1444.  
  1445. static void ReadAttributes
  1446. # ifdef __STDC__
  1447. (Tree_tTree t)
  1448. # else
  1449. (t)
  1450. Tree_tTree t;
  1451. # endif
  1452. {
  1453.   struct S_9 yyTempo;
  1454.  
  1455.   if (t == Tree_NoTree) {
  1456.     return;
  1457.   }
  1458.   if (t->U_1.V_1.Kind == Tree_Class) {
  1459.     {
  1460.       register Tree_yClass *W_12 = &t->U_1.V_5.Class;
  1461.  
  1462.       if ((Tree_NoCodeClass & W_12->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_12->Properties) != 0X0L) {
  1463.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1464.         Tree_WI(W_12->Name);
  1465.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1466.         IO_WriteNl(Tree_f);
  1467.         TreeC2_GetIterator(t);
  1468.         iClassName = W_12->Name;
  1469.         Tree_ForallAttributes(t, (Tree_ProcOfT)ReadAttributes);
  1470.         if (TreeC2_Iterator == Tree_NoTree) {
  1471.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  1472.           IO_WriteNl(Tree_f);
  1473.         } else {
  1474.           IO_WriteS(Tree_f, (STRING)"yySkip (); yyt = & ((* yyt)->", 29L);
  1475.           Tree_WI(iClassName);
  1476.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1477.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  1478.           IO_WriteS(Tree_f, (STRING)"); break;", 9L);
  1479.           IO_WriteNl(Tree_f);
  1480.         }
  1481.       }
  1482.       return;
  1483.     }
  1484.   }
  1485.   if (t->U_1.V_1.Kind == Tree_Child) {
  1486.     {
  1487.       register Tree_yChild *W_13 = &t->U_1.V_9.Child;
  1488.  
  1489.       if (t != TreeC2_Iterator) {
  1490.         IO_WriteS(Tree_f, (STRING)"yySkip (); read", 15L);
  1491.         Tree_WI(Tree_itTree);
  1492.         IO_WriteS(Tree_f, (STRING)" (& ((* yyt)->", 14L);
  1493.         Tree_WI(iClassName);
  1494.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1495.         Tree_WI(W_13->Name);
  1496.         IO_WriteS(Tree_f, (STRING)"))", 2L);
  1497.         IO_WriteNl(Tree_f);
  1498.       }
  1499.       return;
  1500.     }
  1501.   }
  1502.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1503.     {
  1504.       register Tree_yAttribute *W_14 = &t->U_1.V_10.Attribute;
  1505.  
  1506.       if ((Tree_NoCodeAttr & W_14->Properties) == 0X0L) {
  1507.         IO_WriteS(Tree_f, (STRING)"yySkip (); read", 15L);
  1508.         Tree_WI(W_14->Type);
  1509.         IO_WriteS(Tree_f, (STRING)" ((* yyt)->", 11L);
  1510.         Tree_WI(iClassName);
  1511.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1512.         Tree_WI(W_14->Name);
  1513.         IO_WriteS(Tree_f, (STRING)") yyReadNl ();", 14L);
  1514.         IO_WriteNl(Tree_f);
  1515.       }
  1516.       return;
  1517.     }
  1518.   }
  1519. }
  1520.  
  1521. static void PutAttributes
  1522. # ifdef __STDC__
  1523. (Tree_tTree t)
  1524. # else
  1525. (t)
  1526. Tree_tTree t;
  1527. # endif
  1528. {
  1529.   struct S_10 yyTempo;
  1530.  
  1531.   if (t == Tree_NoTree) {
  1532.     return;
  1533.   }
  1534.   if (t->U_1.V_1.Kind == Tree_Class) {
  1535.     {
  1536.       register Tree_yClass *W_15 = &t->U_1.V_5.Class;
  1537.  
  1538.       if ((Tree_NoCodeClass & W_15->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_15->Properties) != 0X0L) {
  1539.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1540.         Tree_WI(W_15->Name);
  1541.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1542.         IO_WriteNl(Tree_f);
  1543.         TreeC2_GetIterator(t);
  1544.         iClassName = W_15->Name;
  1545.         Tree_ForallAttributes(t, (Tree_ProcOfT)PutAttributes);
  1546.         if (TreeC2_Iterator == Tree_NoTree) {
  1547.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  1548.           IO_WriteNl(Tree_f);
  1549.         } else {
  1550.           IO_WriteS(Tree_f, (STRING)"yyt = yyt->", 11L);
  1551.           Tree_WI(iClassName);
  1552.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1553.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  1554.           IO_WriteS(Tree_f, (STRING)"; break;", 8L);
  1555.           IO_WriteNl(Tree_f);
  1556.         }
  1557.       }
  1558.       return;
  1559.     }
  1560.   }
  1561.   if (t->U_1.V_1.Kind == Tree_Child) {
  1562.     {
  1563.       register Tree_yChild *W_16 = &t->U_1.V_9.Child;
  1564.  
  1565.       if (t != TreeC2_Iterator) {
  1566.         IO_WriteS(Tree_f, (STRING)"put", 3L);
  1567.         Tree_WI(Tree_itTree);
  1568.         IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  1569.         Tree_WI(iClassName);
  1570.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1571.         Tree_WI(W_16->Name);
  1572.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1573.         IO_WriteNl(Tree_f);
  1574.       }
  1575.       return;
  1576.     }
  1577.   }
  1578.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1579.     {
  1580.       register Tree_yAttribute *W_17 = &t->U_1.V_10.Attribute;
  1581.  
  1582.       if ((Tree_NoCodeAttr & W_17->Properties) == 0X0L) {
  1583.         IO_WriteS(Tree_f, (STRING)"put", 3L);
  1584.         Tree_WI(W_17->Type);
  1585.         IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  1586.         Tree_WI(iClassName);
  1587.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1588.         Tree_WI(W_17->Name);
  1589.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1590.         IO_WriteNl(Tree_f);
  1591.       }
  1592.       return;
  1593.     }
  1594.   }
  1595. }
  1596.  
  1597. static void GetAttributes
  1598. # ifdef __STDC__
  1599. (Tree_tTree t)
  1600. # else
  1601. (t)
  1602. Tree_tTree t;
  1603. # endif
  1604. {
  1605.   struct S_11 yyTempo;
  1606.  
  1607.   if (t == Tree_NoTree) {
  1608.     return;
  1609.   }
  1610.   if (t->U_1.V_1.Kind == Tree_Class) {
  1611.     {
  1612.       register Tree_yClass *W_18 = &t->U_1.V_5.Class;
  1613.  
  1614.       if ((Tree_NoCodeClass & W_18->Properties) == 0X0L && ((SET_ELEM(Tree_HasChildren) | SET_ELEM(Tree_HasAttributes)) & W_18->Properties) != 0X0L) {
  1615.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1616.         Tree_WI(W_18->Name);
  1617.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1618.         IO_WriteNl(Tree_f);
  1619.         TreeC2_GetIterator(t);
  1620.         iClassName = W_18->Name;
  1621.         Tree_ForallAttributes(t, (Tree_ProcOfT)GetAttributes);
  1622.         if (TreeC2_Iterator == Tree_NoTree) {
  1623.           IO_WriteS(Tree_f, (STRING)"return;", 7L);
  1624.           IO_WriteNl(Tree_f);
  1625.         } else {
  1626.           IO_WriteS(Tree_f, (STRING)"yyt = & ((* yyt)->", 18L);
  1627.           Tree_WI(iClassName);
  1628.           IO_WriteS(Tree_f, (STRING)".", 1L);
  1629.           Tree_WI(TreeC2_Iterator->U_1.V_9.Child.Name);
  1630.           IO_WriteS(Tree_f, (STRING)"); break;", 9L);
  1631.           IO_WriteNl(Tree_f);
  1632.         }
  1633.       }
  1634.       return;
  1635.     }
  1636.   }
  1637.   if (t->U_1.V_1.Kind == Tree_Child) {
  1638.     {
  1639.       register Tree_yChild *W_19 = &t->U_1.V_9.Child;
  1640.  
  1641.       if (t != TreeC2_Iterator) {
  1642.         IO_WriteS(Tree_f, (STRING)"get", 3L);
  1643.         Tree_WI(Tree_itTree);
  1644.         IO_WriteS(Tree_f, (STRING)" (& ((* yyt)->", 14L);
  1645.         Tree_WI(iClassName);
  1646.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1647.         Tree_WI(W_19->Name);
  1648.         IO_WriteS(Tree_f, (STRING)"))", 2L);
  1649.         IO_WriteNl(Tree_f);
  1650.       }
  1651.       return;
  1652.     }
  1653.   }
  1654.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1655.     {
  1656.       register Tree_yAttribute *W_20 = &t->U_1.V_10.Attribute;
  1657.  
  1658.       if ((Tree_NoCodeAttr & W_20->Properties) == 0X0L) {
  1659.         IO_WriteS(Tree_f, (STRING)"get", 3L);
  1660.         Tree_WI(W_20->Type);
  1661.         IO_WriteS(Tree_f, (STRING)" ((* yyt)->", 11L);
  1662.         Tree_WI(iClassName);
  1663.         IO_WriteS(Tree_f, (STRING)".", 1L);
  1664.         Tree_WI(W_20->Name);
  1665.         IO_WriteS(Tree_f, (STRING)")", 1L);
  1666.         IO_WriteNl(Tree_f);
  1667.       }
  1668.       return;
  1669.     }
  1670.   }
  1671. }
  1672.  
  1673. void TreeC2_GetIterator
  1674. # ifdef __STDC__
  1675. (Tree_tTree t)
  1676. # else
  1677. (t)
  1678. Tree_tTree t;
  1679. # endif
  1680. {
  1681.   struct S_12 yyTempo;
  1682.  
  1683.   if (t == Tree_NoTree) {
  1684.     return;
  1685.   }
  1686.   if (t->U_1.V_1.Kind == Tree_Class) {
  1687.     {
  1688.       register Tree_yClass *W_21 = &t->U_1.V_5.Class;
  1689.  
  1690.       TreeC2_Iterator = Tree_NoTree;
  1691.       RevChild = Tree_NoTree;
  1692.       Tree_ForallAttributes(t, (Tree_ProcOfT)TreeC2_GetIterator);
  1693.       if (RevChild != Tree_NoTree) {
  1694.         TreeC2_Iterator = RevChild;
  1695.       }
  1696.       return;
  1697.     }
  1698.   }
  1699.   if (t->U_1.V_1.Kind == Tree_Child) {
  1700.     {
  1701.       register Tree_yChild *W_22 = &t->U_1.V_9.Child;
  1702.  
  1703.       TreeC2_Iterator = t;
  1704.       if (IN(Tree_Reverse, W_22->Properties)) {
  1705.         RevChild = t;
  1706.       }
  1707.       return;
  1708.     }
  1709.   }
  1710. }
  1711.  
  1712. void TreeC2_BeginTreeC2
  1713. # ifdef __STDC__
  1714. ()
  1715. # else
  1716. ()
  1717. # endif
  1718. {
  1719. }
  1720.  
  1721. void TreeC2_CloseTreeC2
  1722. # ifdef __STDC__
  1723. ()
  1724. # else
  1725. ()
  1726. # endif
  1727. {
  1728. }
  1729.  
  1730. static void yyExit
  1731. # ifdef __STDC__
  1732. ()
  1733. # else
  1734. ()
  1735. # endif
  1736. {
  1737.   IO_CloseIO();
  1738.   Exit(1L);
  1739. }
  1740.  
  1741. void BEGIN_TreeC2()
  1742. {
  1743.   static BOOLEAN has_been_called = FALSE;
  1744.  
  1745.   if (!has_been_called) {
  1746.     has_been_called = TRUE;
  1747.  
  1748.     BEGIN_IO();
  1749.     BEGIN_Tree();
  1750.     BEGIN_Positions();
  1751.     BEGIN_System();
  1752.     BEGIN_IO();
  1753.     BEGIN_Tree();
  1754.     BEGIN_IO();
  1755.     BEGIN_Sets();
  1756.     BEGIN_Idents();
  1757.     BEGIN_Positions();
  1758.     BEGIN_Tree();
  1759.  
  1760.     TreeC2_yyf = IO_StdOutput;
  1761.     TreeC2_Exit = yyExit;
  1762.     TreeC2_BeginTreeC2();
  1763.   }
  1764. }
  1765.